using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using 游戏服务器.模板类;
using 游戏服务器.数据类;
using 游戏服务器.网络类;

namespace 游戏服务器.地图类
{
	public sealed class 怪物实例 : 地图对象
	{
		public byte 宠物等级;

		public 游戏怪物 对象模板;

		public int 复活间隔;

		public 对象仇恨 对象仇恨;

		public Point[] 出生范围;

		public 地图实例 出生地图;

		public 游戏技能 普通攻击技能;

		public 游戏技能 概率触发技能;

		public 游戏技能 进入战斗技能;

		public 游戏技能 退出战斗技能;

		public 游戏技能 死亡释放技能;

		public 游戏技能 移动释放技能;

		public 游戏技能 出生释放技能;

		public bool 禁止复活 { get; set; }

		public bool 尸体消失 { get; set; }

		public DateTime 攻击时间 { get; set; }

		public DateTime 漫游时间 { get; set; }

		public DateTime 复活时间 { get; set; }

		public DateTime 消失时间 { get; set; }

		public DateTime 存活时间 { get; set; }

		public override int 处理间隔 => 10;

		public override DateTime 忙碌时间
		{
			get
			{
				return base.忙碌时间;
			}
			set
			{
				if (base.忙碌时间 < value)
				{
					base.忙碌时间 = (this.硬直时间 = value);
				}
			}
		}

		public override DateTime 硬直时间
		{
			get
			{
				return base.硬直时间;
			}
			set
			{
				if (base.硬直时间 < value)
				{
					base.硬直时间 = value;
				}
			}
		}

		public override int 当前体力
		{
			get
			{
				return base.当前体力;
			}
			set
			{
				value = 计算类.数值限制(0, value, this[游戏对象属性.最大体力]);
				if (base.当前体力 != value)
				{
					base.当前体力 = value;
					base.发送封包(new 同步对象体力
					{
						对象编号 = this.地图编号,
						当前体力 = this.当前体力,
						体力上限 = this[游戏对象属性.最大体力]
					});
				}
			}
		}

		public override 地图实例 当前地图
		{
			get
			{
				return base.当前地图;
			}
			set
			{
				if (this.当前地图 != value)
				{
					base.当前地图?.移除对象(this);
					base.当前地图 = value;
					base.当前地图.添加对象(this);
				}
			}
		}

		public override 游戏方向 当前方向
		{
			get
			{
				return base.当前方向;
			}
			set
			{
				if (this.当前方向 != value)
				{
					base.当前方向 = value;
					base.发送封包(new 对象转动方向
					{
						转向耗时 = 100,
						对象编号 = this.地图编号,
						对象朝向 = (ushort)value
					});
				}
			}
		}

		public override byte 当前等级 => this.对象模板.怪物等级;

		public override string 对象名字 => this.对象模板.怪物名字;

		public override 游戏对象类型 对象类型 => 游戏对象类型.怪物;

		public override 技能范围类型 对象体型 => this.对象模板.怪物体型;

		public override int this[游戏对象属性 属性]
		{
			get
			{
				return base[属性];
			}
			set
			{
				base[属性] = value;
			}
		}

		public 怪物种族分类 怪物种族 => this.对象模板.怪物分类;

		public 怪物级别分类 怪物级别 => this.对象模板.怪物级别;

		public List<怪物掉落> 怪物掉落 => this.对象模板.怪物掉落物品;

		public ushort 模板编号 => this.对象模板.怪物编号;

		public int 怪物经验 => this.对象模板.怪物提供经验;

		public int 仇恨范围
		{
			get
			{
				if (this.当前地图.地图编号 != 80)
				{
					return this.对象模板.怪物仇恨范围;
				}
				return 25;
			}
		}

		public int 移动间隔 => this.对象模板.怪物移动间隔;

		public int 切换间隔 => 5000;

		public int 漫游间隔 => this.对象模板.怪物漫游间隔;

		public int 仇恨时长 => this.对象模板.怪物仇恨时间;

		public int 尸体保留 => this.对象模板.尸体保留时长;

		public bool 怪物禁止移动 => this.对象模板.怪物禁止移动;

		public bool 可被技能推动 => this.对象模板.可被技能推动;

		public bool 可见隐身目标 => this.对象模板.可见隐身目标;

		public bool 可被技能控制 => this.对象模板.可被技能控制;

		public bool 可被技能诱惑 => this.对象模板.可被技能诱惑;

		public float 基础诱惑概率 => this.对象模板.基础诱惑概率;

		public bool 主动攻击目标 => this.对象模板.主动攻击目标;

		public 怪物实例(宠物实例 对应宠物)
		{
			Class2.sov79KqzBKBU1();
			//base._002Ector();
			this.地图编号 = ++地图处理网关.对象编号;
			this.对象模板 = 对应宠物.对象模板;
			this.当前地图 = 对应宠物.当前地图;
			this.当前坐标 = 对应宠物.当前坐标;
			this.当前方向 = 对应宠物.当前方向;
			this.宠物等级 = 对应宠物.宠物等级;
			this.禁止复活 = true;
			this.对象仇恨 = new 对象仇恨();
			this.存活时间 = 主程.当前时间.AddHours(2.0);
			base.恢复时间 = 主程.当前时间.AddSeconds(5.0);
			this.攻击时间 = 主程.当前时间.AddSeconds(1.0);
			this.漫游时间 = 主程.当前时间.AddMilliseconds(this.漫游间隔);
			base.属性加成[this] = 对应宠物.基础属性;
			this.更新对象属性();
			this.当前体力 = Math.Min(对应宠物.当前体力, this[游戏对象属性.最大体力]);
			string text;
			text = this.对象模板.普通攻击技能;
			if (text != null && text.Length > 0)
			{
				游戏技能.数据表.TryGetValue(this.对象模板.普通攻击技能, out this.普通攻击技能);
			}
			string text2;
			text2 = this.对象模板.概率触发技能;
			if (text2 != null && text2.Length > 0)
			{
				游戏技能.数据表.TryGetValue(this.对象模板.概率触发技能, out this.概率触发技能);
			}
			string text3;
			text3 = this.对象模板.进入战斗技能;
			if (text3 != null && text3.Length > 0)
			{
				游戏技能.数据表.TryGetValue(this.对象模板.进入战斗技能, out this.进入战斗技能);
			}
			string text4;
			text4 = this.对象模板.退出战斗技能;
			if (text4 != null && text4.Length > 0)
			{
				游戏技能.数据表.TryGetValue(this.对象模板.退出战斗技能, out this.退出战斗技能);
			}
			string text5;
			text5 = this.对象模板.死亡释放技能;
			if (text5 != null && text5.Length > 0)
			{
				游戏技能.数据表.TryGetValue(this.对象模板.死亡释放技能, out this.死亡释放技能);
			}
			string text6;
			text6 = this.对象模板.移动释放技能;
			if (text6 != null && text6.Length > 0)
			{
				游戏技能.数据表.TryGetValue(this.对象模板.移动释放技能, out this.移动释放技能);
			}
			string text7;
			text7 = this.对象模板.出生释放技能;
			if (text7 != null && text7.Length > 0)
			{
				游戏技能.数据表.TryGetValue(this.对象模板.出生释放技能, out this.出生释放技能);
			}
			对应宠物.自身死亡处理(null, 技能击杀: false);
			对应宠物.删除对象();
			this.对象死亡 = false;
			base.战斗姿态 = false;
			this.阻塞网格 = true;
			base.绑定网格();
			base.更新邻居时处理();
			地图处理网关.添加地图对象(this);
		}

		public 怪物实例(游戏怪物 对应模板, 地图实例 出生地图, int 复活间隔, Point[] 出生范围, bool 禁止复活, bool 立即刷新)
		{
			Class2.sov79KqzBKBU1();
			//base._002Ector();
			this.对象模板 = 对应模板;
			this.出生地图 = 出生地图;
			this.当前地图 = 出生地图;
			this.复活间隔 = 复活间隔;
			this.出生范围 = 出生范围;
			this.禁止复活 = 禁止复活;
			this.地图编号 = ++地图处理网关.对象编号;
			base.属性加成[this] = 对应模板.基础属性;
			string text;
			text = this.对象模板.普通攻击技能;
			if (text != null && text.Length > 0)
			{
				游戏技能.数据表.TryGetValue(this.对象模板.普通攻击技能, out this.普通攻击技能);
			}
			string text2;
			text2 = this.对象模板.概率触发技能;
			if (text2 != null && text2.Length > 0)
			{
				游戏技能.数据表.TryGetValue(this.对象模板.概率触发技能, out this.概率触发技能);
			}
			string text3;
			text3 = this.对象模板.进入战斗技能;
			if (text3 != null && text3.Length > 0)
			{
				游戏技能.数据表.TryGetValue(this.对象模板.进入战斗技能, out this.进入战斗技能);
			}
			string text4;
			text4 = this.对象模板.退出战斗技能;
			if (text4 != null && text4.Length > 0)
			{
				游戏技能.数据表.TryGetValue(this.对象模板.退出战斗技能, out this.退出战斗技能);
			}
			string text5;
			text5 = this.对象模板.死亡释放技能;
			if (text5 != null && text5.Length > 0)
			{
				游戏技能.数据表.TryGetValue(this.对象模板.死亡释放技能, out this.死亡释放技能);
			}
			string text6;
			text6 = this.对象模板.移动释放技能;
			if (text6 != null && text6.Length > 0)
			{
				游戏技能.数据表.TryGetValue(this.对象模板.移动释放技能, out this.移动释放技能);
			}
			string text7;
			text7 = this.对象模板.出生释放技能;
			if (text7 != null && text7.Length > 0)
			{
				游戏技能.数据表.TryGetValue(this.对象模板.出生释放技能, out this.出生释放技能);
			}
			地图处理网关.添加地图对象(this);
			if (!禁止复活)
			{
				this.当前地图.固定怪物总数++;
				主窗口.更新地图数据(this.当前地图, "固定怪物总数", this.当前地图.固定怪物总数);
			}
			if (立即刷新)
			{
				this.怪物复活处理(计算复活: false);
				return;
			}
			this.复活时间 = 主程.当前时间.AddMilliseconds(复活间隔);
			this.阻塞网格 = false;
			this.尸体消失 = true;
			this.对象死亡 = true;
			base.次要对象 = true;
			地图处理网关.添加次要对象(this);
		}

		public override void 处理对象数据()
		{
			if (主程.当前时间 < base.预约时间)
			{
				return;
			}
			if (this.禁止复活 && 主程.当前时间 >= this.存活时间)
			{
				base.删除对象();
			}
			else if (this.对象死亡)
			{
				if (!this.尸体消失 && 主程.当前时间 >= this.消失时间)
				{
					if (this.禁止复活)
					{
						base.删除对象();
					}
					else
					{
						this.尸体消失 = true;
						base.清空邻居时处理();
						base.解绑网格();
					}
				}
				if (!this.禁止复活 && 主程.当前时间 >= this.复活时间)
				{
					base.清空邻居时处理();
					base.解绑网格();
					this.怪物复活处理(计算复活: true);
				}
			}
			else
			{
				foreach (KeyValuePair<ushort, Buff数据> item in this.Buff列表.ToList())
				{
					base.轮询Buff时处理(item.Value);
				}
				foreach (技能实例 item2 in base.技能任务.ToList())
				{
					item2.处理任务();
				}
				if (主程.当前时间 > base.恢复时间)
				{
					if (!this.检查状态(游戏对象状态.中毒状态))
					{
						this.当前体力 += this[游戏对象属性.体力恢复];
					}
					base.恢复时间 = 主程.当前时间.AddSeconds(5.0);
				}
				if (主程.当前时间 > base.治疗时间 && base.治疗次数 > 0)
				{
					base.治疗次数--;
					base.治疗时间 = 主程.当前时间.AddMilliseconds(500.0);
					this.当前体力 += base.治疗基数;
				}
				if (主程.当前时间 > this.忙碌时间 && 主程.当前时间 > this.硬直时间)
				{
					if (this.进入战斗技能 != null && !base.战斗姿态 && this.对象仇恨.仇恨列表.Count != 0)
					{
						new 技能实例(this, this.进入战斗技能, null, base.动作编号++, this.当前地图, this.当前坐标, null, this.当前坐标, null);
						base.战斗姿态 = true;
						base.脱战时间 = 主程.当前时间.AddSeconds(10.0);
					}
					else if (this.退出战斗技能 != null && base.战斗姿态 && this.对象仇恨.仇恨列表.Count == 0 && 主程.当前时间 > base.脱战时间)
					{
						new 技能实例(this, this.退出战斗技能, null, base.动作编号++, this.当前地图, this.当前坐标, null, this.当前坐标, null);
						base.战斗姿态 = false;
					}
					else if (this.对象模板.脱战自动石化 && !base.战斗姿态 && this.对象仇恨.仇恨列表.Count != 0)
					{
						base.战斗姿态 = true;
						base.移除Buff时处理(this.对象模板.石化状态编号);
						base.脱战时间 = 主程.当前时间.AddSeconds(10.0);
					}
					else if (this.对象模板.脱战自动石化 && base.战斗姿态 && this.对象仇恨.仇恨列表.Count == 0 && 主程.当前时间 > base.脱战时间)
					{
						base.战斗姿态 = false;
						base.添加Buff时处理(this.对象模板.石化状态编号, this);
					}
					else if ((this.怪物级别 == 怪物级别分类.头目首领) ? this.更新最近仇恨() : this.更新对象仇恨())
					{
						this.怪物智能攻击();
					}
					else
					{
						this.怪物随机漫游();
					}
				}
			}
			base.处理对象数据();
		}

		public override void 自身死亡处理(地图对象 对象, bool 技能击杀)
		{
			foreach (技能实例 item in base.技能任务)
			{
				item.技能中断();
			}
			base.自身死亡处理(对象, 技能击杀);
			if (this.死亡释放技能 != null && 对象 != null)
			{
				new 技能实例(this, this.死亡释放技能, null, base.动作编号++, this.当前地图, this.当前坐标, null, this.当前坐标, null).处理任务();
			}
			if (this.当前地图.副本地图 || !this.禁止复活)
			{
				this.当前地图.存活怪物总数--;
				主窗口.更新地图数据(this.当前地图, "存活怪物总数", -1);
			}
			this.尸体消失 = false;
			this.消失时间 = 主程.当前时间.AddMilliseconds(this.尸体保留);
			this.复活时间 = 主程.当前时间.AddMilliseconds(Math.Max(this.复活间隔, this.尸体保留 + 5000));
			if (对象 is 宠物实例 宠物实例2)
			{
				宠物实例2.宠物经验增加();
			}
			if (this.更新怪物归属(out var 归属玩家))
			{
				if (this.当前地图.地图编号 == 80)
				{
					int num;
					num = 0;
					if (游戏物品.检索表.TryGetValue("强效金创药", out var value))
					{
						int num2;
						num2 = ((this.怪物级别 != 怪物级别分类.普通怪物) ? 1 : 15);
						int num3;
						num3 = Math.Max(1, num2 - (int)Math.Round((decimal)num2 * 自定义类.怪物额外爆率));
						if (主程.随机数.Next(num3) == num3 / 2)
						{
							num++;
							new 物品实例(value, null, this.当前地图, this.当前坐标, new HashSet<角色数据>(), 1);
						}
					}
					if (游戏物品.检索表.TryGetValue("强效魔法药", out var value2))
					{
						int num4;
						num4 = ((this.怪物级别 != 怪物级别分类.普通怪物) ? 1 : 20);
						int num5;
						num5 = Math.Max(1, num4 - (int)Math.Round((decimal)num4 * 自定义类.怪物额外爆率));
						if (主程.随机数.Next(num5) == num5 / 2)
						{
							num++;
							new 物品实例(value2, null, this.当前地图, this.当前坐标, new HashSet<角色数据>(), 1);
						}
					}
					if (游戏物品.检索表.TryGetValue("疗伤药", out var value3))
					{
						int num6;
						num6 = ((this.怪物级别 != 怪物级别分类.普通怪物) ? 1 : 100);
						int num7;
						num7 = Math.Max(1, num6 - (int)Math.Round((decimal)num6 * 自定义类.怪物额外爆率));
						if (主程.随机数.Next(num7) == num7 / 2)
						{
							num++;
							new 物品实例(value3, null, this.当前地图, this.当前坐标, new HashSet<角色数据>(), 1);
						}
					}
					if (游戏物品.检索表.TryGetValue("祝福油", out var value4))
					{
						int num8;
						num8 = ((this.怪物级别 == 怪物级别分类.普通怪物) ? 1000 : ((this.怪物级别 == 怪物级别分类.精英干将) ? 50 : 10));
						int num9;
						num9 = Math.Max(1, num8 - (int)Math.Round((decimal)num8 * 自定义类.怪物额外爆率));
						if (主程.随机数.Next(num9) == num9 / 2)
						{
							num++;
							new 物品实例(value4, null, this.当前地图, this.当前坐标, new HashSet<角色数据>(), 1);
							网络服务网关.发送公告("[" + this.对象名字 + "] 被 [" + 归属玩家.对象名字 + "] 击杀, 掉落了[祝福油]");
						}
					}
					if (num > 0)
					{
						主窗口.更新地图数据(this.当前地图, "怪物掉落次数", num);
					}
					foreach (玩家实例 item2 in this.当前地图.玩家列表)
					{
						item2.玩家增加经验(this, (int)((float)this.怪物经验 * 1.5f));
					}
				}
				else
				{
					HashSet<角色数据> 物品归属;
					物品归属 = ((归属玩家.所属队伍 == null) ? new HashSet<角色数据> { 归属玩家.角色数据 } : new HashSet<角色数据>(归属玩家.所属队伍.队伍成员));
					float num10;
					num10 = 计算类.收益衰减(归属玩家.当前等级, this.当前等级);
					int num11;
					num11 = 0;
					int num12;
					num12 = 0;
					if (num10 < 1f)
					{
						foreach (怪物掉落 item3 in this.怪物掉落)
						{
							if (!游戏物品.检索表.TryGetValue(item3.物品名字, out var value5) || 计算类.计算概率(num10) || (归属玩家.本期特权 == 0 && this.怪物级别 != 怪物级别分类.头目首领 && value5.物品分类 != 物品使用分类.可用药剂 && 计算类.计算概率(0.5f)) || (归属玩家.本期特权 == 3 && this.怪物级别 != 怪物级别分类.头目首领 && value5.物品分类 != 物品使用分类.可用药剂 && 计算类.计算概率(0.25f)))
							{
								continue;
							}
							int num13;
							num13 = Math.Max(1, item3.掉落概率 - (int)Math.Round((decimal)item3.掉落概率 * 自定义类.怪物额外爆率));
							if (主程.随机数.Next(num13) != num13 / 2)
							{
								continue;
							}
							int num14;
							num14 = 主程.随机数.Next(item3.最小数量, item3.最大数量 + 1);
							if (num14 == 0)
							{
								continue;
							}
							if (value5.物品持久 == 0)
							{
								new 物品实例(value5, null, this.当前地图, this.当前坐标, 物品归属, num14);
								if (value5.物品编号 == 1)
								{
									this.当前地图.金币掉落总数 += num14;
									num11 = num14;
								}
								this.对象模板.掉落统计[value5] = (this.对象模板.掉落统计.ContainsKey(value5) ? this.对象模板.掉落统计[value5] : 0L) + num14;
							}
							else
							{
								for (int i = 0; i < num14; i++)
								{
									new 物品实例(value5, null, this.当前地图, this.当前坐标, 物品归属, 1);
								}
								this.当前地图.怪物掉落次数 += num14;
								num12++;
								this.对象模板.掉落统计[value5] = (this.对象模板.掉落统计.ContainsKey(value5) ? this.对象模板.掉落统计[value5] : 0L) + num14;
							}
							if (value5.贵重物品)
							{
								网络服务网关.发送公告("[" + this.对象名字 + "] 被 [" + 归属玩家.对象名字 + "] 击杀, 掉落了[" + value5.物品名字 + "]");
							}
						}
					}
					if (num11 > 0)
					{
						主窗口.更新地图数据(this.当前地图, "金币掉落总数", num11);
					}
					if (num12 > 0)
					{
						主窗口.更新地图数据(this.当前地图, "怪物掉落次数", num12);
					}
					if (num11 > 0 || num12 > 0)
					{
						主窗口.更新掉落统计(this.对象模板, this.对象模板.掉落统计.ToList());
					}
					if (归属玩家.所属队伍 == null)
					{
						归属玩家.玩家增加经验(this, this.怪物经验);
					}
					else
					{
						List<玩家实例> list;
						list = new List<玩家实例> { 归属玩家 };
						foreach (地图对象 item4 in base.重要邻居)
						{
							if (item4 != 归属玩家 && item4 is 玩家实例 玩家实例2 && 玩家实例2.所属队伍 == 归属玩家.所属队伍)
							{
								list.Add(玩家实例2);
							}
						}
						float num15;
						num15 = (float)this.怪物经验 * (1f + (float)(list.Count - 1) * 0.2f);
						float num16;
						num16 = list.Sum((玩家实例 x) => x.当前等级);
						foreach (玩家实例 item5 in list)
						{
							item5.玩家增加经验(this, (int)(num15 * (float)(int)item5.当前等级 / num16));
						}
					}
				}
			}
			this.Buff列表.Clear();
			base.次要对象 = true;
			地图处理网关.添加次要对象(this);
			if (base.激活对象)
			{
				base.激活对象 = false;
				地图处理网关.移除激活对象(this);
			}
		}

		public void 怪物随机漫游()
		{
			if (this.怪物禁止移动 || 主程.当前时间 < this.漫游时间)
			{
				return;
			}
			if (this.能否走动())
			{
				Point point;
				point = 计算类.前方坐标(this.当前坐标, 计算类.随机方向(), 1);
				if (this.当前地图.能否通行(point))
				{
					this.忙碌时间 = 主程.当前时间.AddMilliseconds(this.行走耗时);
					this.行走时间 = 主程.当前时间.AddMilliseconds(this.行走耗时 + this.移动间隔);
					this.当前方向 = 计算类.计算方向(this.当前坐标, point);
					base.自身移动时处理(point);
					if (!this.对象死亡)
					{
						base.发送封包(new 对象角色走动
						{
							对象编号 = this.地图编号,
							移动坐标 = this.当前坐标,
							移动速度 = base.行走速度
						});
					}
				}
			}
			this.漫游时间 = 主程.当前时间.AddMilliseconds(this.漫游间隔 + 主程.随机数.Next(5000));
		}

		public void 怪物智能攻击()
		{
			base.脱战时间 = 主程.当前时间.AddSeconds(10.0);
			游戏技能 游戏技能;
			游戏技能 = null;
			if (this.概率触发技能 != null && (!this.冷却记录.ContainsKey(this.概率触发技能.自身技能编号 | 0x1000000) || 主程.当前时间 > this.冷却记录[this.概率触发技能.自身技能编号 | 0x1000000]) && 计算类.计算概率(this.概率触发技能.计算触发概率))
			{
				游戏技能 = this.概率触发技能;
			}
			else
			{
				if (this.普通攻击技能 == null || (this.冷却记录.ContainsKey(this.普通攻击技能.自身技能编号 | 0x1000000) && !(主程.当前时间 > this.冷却记录[this.普通攻击技能.自身技能编号 | 0x1000000])))
				{
					return;
				}
				游戏技能 = this.普通攻击技能;
			}
			if (this.检查状态(游戏对象状态.忙绿状态 | 游戏对象状态.麻痹状态 | 游戏对象状态.失神状态))
			{
				return;
			}
			if (base.网格距离(this.对象仇恨.当前目标) > 游戏技能.技能最远距离)
			{
				if (this.怪物禁止移动 || !this.能否走动())
				{
					return;
				}
				游戏方向 方向;
				方向 = 计算类.计算方向(this.当前坐标, this.对象仇恨.当前目标.当前坐标);
				Point point;
				point = default(Point);
				int num;
				num = 0;
				while (true)
				{
					if (num < 8)
					{
						if (this.当前地图.能否通行(point = 计算类.前方坐标(this.当前坐标, 方向, 1)))
						{
							break;
						}
						方向 = 计算类.旋转方向(方向, (主程.随机数.Next(2) != 0) ? 1 : (-1));
						num++;
						continue;
					}
					return;
				}
				this.忙碌时间 = 主程.当前时间.AddMilliseconds(this.行走耗时);
				this.行走时间 = 主程.当前时间.AddMilliseconds(this.行走耗时 + this.移动间隔);
				this.当前方向 = 计算类.计算方向(this.当前坐标, point);
				base.发送封包(new 对象角色走动
				{
					对象编号 = this.地图编号,
					移动坐标 = point,
					移动速度 = base.行走速度
				});
				base.自身移动时处理(point);
			}
			else if (游戏技能.需要正向走位 && !计算类.直线方向(this.当前坐标, this.对象仇恨.当前目标.当前坐标))
			{
				if (this.怪物禁止移动 || !this.能否走动())
				{
					return;
				}
				游戏方向 方向2;
				方向2 = 计算类.正向方向(this.当前坐标, this.对象仇恨.当前目标.当前坐标);
				Point point2;
				point2 = default(Point);
				int num2;
				num2 = 0;
				while (true)
				{
					if (num2 < 8)
					{
						if (this.当前地图.能否通行(point2 = 计算类.前方坐标(this.当前坐标, 方向2, 1)))
						{
							break;
						}
						方向2 = 计算类.旋转方向(方向2, (主程.随机数.Next(2) != 0) ? 1 : (-1));
						num2++;
						continue;
					}
					return;
				}
				this.当前方向 = 计算类.计算方向(this.当前坐标, point2);
				this.忙碌时间 = 主程.当前时间.AddMilliseconds(this.行走耗时);
				this.行走时间 = 主程.当前时间.AddMilliseconds(this.行走耗时 + this.移动间隔);
				base.自身移动时处理(point2);
				if (!this.对象死亡)
				{
					base.发送封包(new 对象角色走动
					{
						对象编号 = this.地图编号,
						移动坐标 = point2,
						移动速度 = base.行走速度
					});
				}
			}
			else if (主程.当前时间 > this.攻击时间)
			{
				new 技能实例(this, 游戏技能, null, base.动作编号++, this.当前地图, this.当前坐标, this.对象仇恨.当前目标, this.对象仇恨.当前目标.当前坐标, null);
				this.攻击时间 = 主程.当前时间.AddMilliseconds(计算类.数值限制(0, 10 - this[游戏对象属性.攻击速度], 10) * 500);
			}
			else if (!this.怪物禁止移动 && this.能否转动())
			{
				this.当前方向 = 计算类.计算方向(this.当前坐标, this.对象仇恨.当前目标.当前坐标);
			}
		}

		public void 怪物复活处理(bool 计算复活)
		{
			if (this.当前地图.副本地图 || !this.禁止复活)
			{
				this.当前地图.存活怪物总数++;
				主窗口.更新地图数据(this.当前地图, "存活怪物总数", 1);
				if (计算复活)
				{
					this.当前地图.怪物复活次数++;
					主窗口.更新地图数据(this.当前地图, "怪物复活次数", 1);
				}
			}
			this.更新对象属性();
			this.当前地图 = this.出生地图;
			this.当前方向 = 计算类.随机方向();
			this.当前体力 = this[游戏对象属性.最大体力];
			this.当前坐标 = this.出生范围[主程.随机数.Next(0, this.出生范围.Length)];
			Point point;
			point = this.当前坐标;
			for (int i = 0; i < 100; i++)
			{
				if (!this.当前地图.空间阻塞(point = 计算类.螺旋坐标(this.当前坐标, i)))
				{
					this.当前坐标 = point;
					break;
				}
			}
			this.攻击时间 = 主程.当前时间.AddSeconds(1.0);
			base.恢复时间 = 主程.当前时间.AddMilliseconds(主程.随机数.Next(5000));
			this.漫游时间 = 主程.当前时间.AddMilliseconds(主程.随机数.Next(5000) + this.漫游间隔);
			this.对象仇恨 = new 对象仇恨();
			base.次要对象 = false;
			this.对象死亡 = false;
			base.战斗姿态 = false;
			this.阻塞网格 = true;
			base.绑定网格();
			base.更新邻居时处理();
			if (!base.激活对象)
			{
				if (this.对象模板.脱战自动石化)
				{
					base.添加Buff时处理(this.对象模板.石化状态编号, this);
				}
				if (this.退出战斗技能 != null)
				{
					new 技能实例(this, this.退出战斗技能, null, base.动作编号++, this.当前地图, this.当前坐标, null, this.当前坐标, null).处理任务();
				}
			}
		}

		public void 怪物诱惑处理()
		{
			this.Buff列表.Clear();
			this.尸体消失 = true;
			this.对象死亡 = true;
			this.阻塞网格 = false;
			if (this.禁止复活)
			{
				base.删除对象();
				return;
			}
			base.清空邻居时处理();
			base.解绑网格();
			this.复活时间 = 主程.当前时间.AddMilliseconds(this.复活间隔);
			base.次要对象 = true;
			地图处理网关.添加次要对象(this);
			base.激活对象 = false;
			地图处理网关.移除激活对象(this);
		}

		public void 怪物沉睡处理()
		{
			if (base.激活对象)
			{
				base.激活对象 = false;
				base.技能任务.Clear();
				地图处理网关.移除激活对象(this);
			}
			if (this.禁止复活 && !base.次要对象)
			{
				base.次要对象 = true;
				base.技能任务.Clear();
				地图处理网关.添加次要对象(this);
			}
		}

		public void 怪物激活处理()
		{
			if (!base.激活对象)
			{
				base.次要对象 = false;
				base.激活对象 = true;
				地图处理网关.添加激活对象(this);
				double num;
				num = Math.Max(0.0, (主程.当前时间 - base.恢复时间).TotalSeconds / 5.0);
				base.当前体力 = Math.Min(this[游戏对象属性.最大体力], this.当前体力 + (int)num * this[游戏对象属性.体力恢复]);
				base.恢复时间 = base.恢复时间.AddSeconds(5.0);
				this.攻击时间 = 主程.当前时间.AddSeconds(1.0);
				this.漫游时间 = 主程.当前时间.AddMilliseconds(主程.随机数.Next(5000) + this.漫游间隔);
			}
		}

		public bool 更新对象仇恨()
		{
			if (this.对象仇恨.仇恨列表.Count == 0)
			{
				return false;
			}
			if (this.对象仇恨.当前目标 == null)
			{
				this.对象仇恨.切换时间 = default(DateTime);
			}
			else if (this.对象仇恨.当前目标.对象死亡)
			{
				this.对象仇恨.移除仇恨(this.对象仇恨.当前目标);
			}
			else if (!base.邻居列表.Contains(this.对象仇恨.当前目标))
			{
				this.对象仇恨.移除仇恨(this.对象仇恨.当前目标);
			}
			else if (!this.对象仇恨.仇恨列表.ContainsKey(this.对象仇恨.当前目标))
			{
				this.对象仇恨.移除仇恨(this.对象仇恨.当前目标);
			}
			else if (base.网格距离(this.对象仇恨.当前目标) > this.仇恨范围 && 主程.当前时间 > this.对象仇恨.仇恨列表[this.对象仇恨.当前目标].仇恨时间)
			{
				this.对象仇恨.移除仇恨(this.对象仇恨.当前目标);
			}
			else if (base.网格距离(this.对象仇恨.当前目标) <= this.仇恨范围)
			{
				this.对象仇恨.仇恨列表[this.对象仇恨.当前目标].仇恨时间 = 主程.当前时间.AddMilliseconds(this.仇恨时长);
			}
			if (this.对象仇恨.切换时间 < 主程.当前时间 && this.对象仇恨.切换仇恨(this))
			{
				this.对象仇恨.切换时间 = 主程.当前时间.AddMilliseconds(this.切换间隔);
			}
			if (this.对象仇恨.当前目标 == null)
			{
				return this.更新对象仇恨();
			}
			return true;
		}

		public bool 更新最近仇恨()
		{
			if (this.对象仇恨.仇恨列表.Count == 0)
			{
				return false;
			}
			if (this.对象仇恨.当前目标 == null)
			{
				this.对象仇恨.切换时间 = default(DateTime);
			}
			else if (this.对象仇恨.当前目标.对象死亡)
			{
				this.对象仇恨.移除仇恨(this.对象仇恨.当前目标);
			}
			else if (!base.邻居列表.Contains(this.对象仇恨.当前目标))
			{
				this.对象仇恨.移除仇恨(this.对象仇恨.当前目标);
			}
			else if (!this.对象仇恨.仇恨列表.ContainsKey(this.对象仇恨.当前目标))
			{
				this.对象仇恨.移除仇恨(this.对象仇恨.当前目标);
			}
			else if (base.网格距离(this.对象仇恨.当前目标) > this.仇恨范围 && 主程.当前时间 > this.对象仇恨.仇恨列表[this.对象仇恨.当前目标].仇恨时间)
			{
				this.对象仇恨.移除仇恨(this.对象仇恨.当前目标);
			}
			else if (base.网格距离(this.对象仇恨.当前目标) <= this.仇恨范围)
			{
				this.对象仇恨.仇恨列表[this.对象仇恨.当前目标].仇恨时间 = 主程.当前时间.AddMilliseconds(this.仇恨时长);
			}
			if (this.对象仇恨.切换时间 < 主程.当前时间 && this.对象仇恨.最近仇恨(this))
			{
				this.对象仇恨.切换时间 = 主程.当前时间.AddMilliseconds(this.切换间隔);
			}
			if (this.对象仇恨.当前目标 == null)
			{
				return this.更新对象仇恨();
			}
			return true;
		}

		public void 清空怪物仇恨()
		{
			this.对象仇恨.当前目标 = null;
			this.对象仇恨.仇恨列表.Clear();
		}

		public bool 更新怪物归属(out 玩家实例 归属玩家)
		{
			foreach (KeyValuePair<地图对象, 对象仇恨.仇恨详情> item in this.对象仇恨.仇恨列表.ToList())
			{
				if (item.Key is 宠物实例 宠物实例2)
				{
					if (item.Value.仇恨数值 > 0)
					{
						this.对象仇恨.添加仇恨(宠物实例2.宠物主人, item.Value.仇恨时间, item.Value.仇恨数值);
					}
					this.对象仇恨.移除仇恨(item.Key);
				}
				else if (!(item.Key is 玩家实例))
				{
					this.对象仇恨.移除仇恨(item.Key);
				}
			}
			地图对象 地图对象2;
			地图对象2 = (from x in this.对象仇恨.仇恨列表.Keys.ToList()
				orderby this.对象仇恨.仇恨列表[x].仇恨数值 descending
				select x).FirstOrDefault();
			归属玩家 = ((地图对象2 == null || !(地图对象2 is 玩家实例 玩家实例2)) ? null : 玩家实例2);
			return 归属玩家 != null;
		}
	}
}
